document.addEventListener('DOMContentLoaded', function() {
    // 获取DOM元素
    const jobList = document.querySelector('.job-list');
    const filterDropdown = document.querySelector('.filter-dropdown');
    const searchInput = document.querySelector('.search-input');
    
    // 状态变量
    let currentPosition = null;
    let currentFilter = 'distance';
    let currentKeyword = '';
    let currentPage = 1;
    let isLoading = false;
    let hasMoreJobs = true;
    
    // 模拟获取位置信息
    function getLocation() {
        // 显示加载状态
        showLoadingState(true);
        
        // 如果浏览器支持地理位置
        if (navigator.geolocation) {
            // 尝试获取当前位置
            navigator.geolocation.getCurrentPosition(
                position => {
                    currentPosition = {
                        latitude: position.coords.latitude,
                        longitude: position.coords.longitude
                    };
                    loadNearbyJobs();
                },
                handleLocationError,
                { timeout: 10000 }
            );
        } else {
            console.log("浏览器不支持地理位置功能");
            handleLocationError({ code: 0, message: "您的浏览器不支持地理位置功能" });
        }
    }
    
    // 处理位置获取失败的情况
    function handleLocationError(error) {
        console.log("无法获取位置信息: " + error.message);
        
        // 根据错误类型显示不同消息
        let errorMessage = "无法获取您的位置，将显示默认工作列表";
        
        switch(error.code) {
            case 1: // PERMISSION_DENIED
                errorMessage = "您拒绝了位置访问权限，将显示默认工作列表";
                break;
            case 2: // POSITION_UNAVAILABLE
                errorMessage = "位置信息不可用，将显示默认工作列表";
                break;
            case 3: // TIMEOUT
                errorMessage = "获取位置超时，将显示默认工作列表";
                break;
        }
        
        // 显示错误消息
        showError(errorMessage);
        
        // 加载默认工作列表
        loadDefaultJobs();
    }
    
    // 显示错误消息
    function showError(message) {
        // 创建错误提示元素
        const errorElement = document.createElement('div');
        errorElement.className = 'error-message';
        errorElement.textContent = message;
        
        // 添加到页面
        const pageContent = document.querySelector('.page-content');
        pageContent.insertBefore(errorElement, jobList);
        
        // 3秒后移除
        setTimeout(() => {
            errorElement.classList.add('fade-out');
            setTimeout(() => {
                errorElement.remove();
            }, 300);
        }, 3000);
    }
    
    // 加载附近工作
    async function loadNearbyJobs() {
        try {
            // 如果已经在加载或没有更多数据，直接返回
            if (isLoading || !hasMoreJobs) return;
            
            // 设置加载状态
            isLoading = true;
            showLoadingState(true);
            
            // 准备筛选参数
            const filters = {
                sortBy: currentFilter,
                keyword: currentKeyword,
                page: currentPage,
                limit: 10
            };
            
            // 调用API获取附近工作
            let jobsData;
            if (currentPosition) {
                jobsData = await apiService.getNearbyJobs(
                    currentPosition.latitude,
                    currentPosition.longitude,
                    10, // 10公里范围内
                    filters
                );
            } else {
                // 如果没有位置信息，加载默认工作列表
                jobsData = await apiService.getLatestJobs(currentPage, 10, filters);
            }
            
            // 检查是否还有更多数据
            hasMoreJobs = jobsData.length === 10;
            
            // 如果是第一页，清空列表
            if (currentPage === 1) {
                jobList.innerHTML = '';
            }
            
            // 如果没有工作，显示空状态
            if (jobsData.length === 0 && currentPage === 1) {
                showEmptyState();
            } else {
                // 渲染工作列表
                renderJobs(jobsData);
                
                // 增加页码
                currentPage++;
            }
        } catch (error) {
            console.error('加载工作失败:', error);
            showError('加载工作失败，请稍后再试');
        } finally {
            // 结束加载状态
            isLoading = false;
            showLoadingState(false);
        }
    }
    
    // 加载默认工作列表
    async function loadDefaultJobs() {
        try {
            // 设置加载状态
            isLoading = true;
            showLoadingState(true);
            
            // 准备筛选参数
            const filters = {
                sortBy: currentFilter,
                keyword: currentKeyword,
                page: currentPage,
                limit: 10
            };
            
            // 调用API获取最新工作
            const jobsData = await apiService.getLatestJobs(currentPage, 10, filters);
            
            // 检查是否还有更多数据
            hasMoreJobs = jobsData.length === 10;
            
            // 清空列表并渲染
            jobList.innerHTML = '';
            
            // 如果没有工作，显示空状态
            if (jobsData.length === 0) {
                showEmptyState();
            } else {
                renderJobs(jobsData);
                
                // 增加页码
                currentPage++;
            }
        } catch (error) {
            console.error('加载工作失败:', error);
            showError('加载工作失败，请稍后再试');
        } finally {
            // 结束加载状态
            isLoading = false;
            showLoadingState(false);
        }
    }
    
    // 搜索工作
    async function searchJobs() {
        try {
            // 重置页码
            currentPage = 1;
            
            // 设置加载状态
            isLoading = true;
            showLoadingState(true);
            
            // 准备筛选参数
            const filters = {
                sortBy: currentFilter
            };
            
            // 调用API搜索工作
            const jobsData = await apiService.searchJobs(currentKeyword, filters, currentPage, 10);
            
            // 检查是否还有更多数据
            hasMoreJobs = jobsData.length === 10;
            
            // 清空列表
            jobList.innerHTML = '';
            
            // 如果没有工作，显示空状态
            if (jobsData.length === 0) {
                showEmptyState('没有找到符合条件的工作');
            } else {
                renderJobs(jobsData);
                
                // 增加页码
                currentPage++;
            }
        } catch (error) {
            console.error('搜索工作失败:', error);
            showError('搜索工作失败，请稍后再试');
        } finally {
            // 结束加载状态
            isLoading = false;
            showLoadingState(false);
        }
    }
    
    // 渲染工作列表
    function renderJobs(jobs) {
        // 创建文档片段，提高性能
        const fragment = document.createDocumentFragment();
        
        jobs.forEach((job, index) => {
            // 创建工作卡片
            const jobCard = document.createElement('div');
            jobCard.className = 'job-card';
            jobCard.dataset.id = job.id;
            
            // 添加动画延迟
            jobCard.style.animationDelay = `${index * 100}ms`;
            
            // 构建卡片内容
            jobCard.innerHTML = `
                <div class="job-header">
                    <h3 class="job-title">${job.title}</h3>
                    <span class="job-salary">${job.salary}</span>
                </div>
                <div class="company-info">
                    <span class="company-name">${job.company.name}</span>
                    <span class="location">${formatDistance(job.distance)}</span>
                </div>
                <div class="job-tags">
                    ${job.tags.map(tag => `<span class="tag">${tag}</span>`).join('')}
                </div>
            `;
            
            // 添加点击事件
            jobCard.addEventListener('click', () => {
                navigateToJobDetail(job.id);
            });
            
            // 添加到文档片段
            fragment.appendChild(jobCard);
        });
        
        // 一次性添加到DOM
        jobList.appendChild(fragment);
        
        // 添加淡入动画
        setTimeout(() => {
            document.querySelectorAll('.job-card').forEach(card => {
                card.classList.add('show');
            });
        }, 10);
    }
    
    // 显示空状态
    function showEmptyState(message = '未找到附近的工作') {
        jobList.innerHTML = `
            <div class="empty-state">
                <img src="../images/empty.svg" alt="没有数据" class="empty-icon">
                <p>${message}</p>
                <button class="retry-button">重新加载</button>
            </div>
        `;
        
        // 添加重试按钮事件
        jobList.querySelector('.retry-button').addEventListener('click', () => {
            // 重置页码
            currentPage = 1;
            
            // 重新加载
            if (currentPosition) {
                loadNearbyJobs();
            } else {
                loadDefaultJobs();
            }
        });
    }
    
    // 设置加载状态
    function showLoadingState(isLoading) {
        if (isLoading) {
            // 添加加载指示器
            if (!document.querySelector('.loading-indicator')) {
                const loadingIndicator = document.createElement('div');
                loadingIndicator.className = 'loading-indicator';
                loadingIndicator.innerHTML = '<div class="spinner"></div>';
                document.querySelector('.page-content').appendChild(loadingIndicator);
            }
        } else {
            // 移除加载指示器
            const loadingIndicator = document.querySelector('.loading-indicator');
            if (loadingIndicator) {
                loadingIndicator.remove();
            }
        }
    }
    
    // 格式化距离
    function formatDistance(distance) {
        if (!distance) return '未知距离';
        
        // 如果是数字，格式化为千米
        if (typeof distance === 'number') {
            if (distance < 1) {
                return `距离: ${Math.round(distance * 1000)}m`;
            } else {
                return `距离: ${distance.toFixed(1)}km`;
            }
        }
        
        // 如果已经是字符串，直接返回
        return `距离: ${distance}`;
    }
    
    // 导航到工作详情页
    function navigateToJobDetail(jobId) {
        window.location.href = `../pages/job-detail.html?id=${jobId}`;
    }
    
    // 筛选功能
    if (filterDropdown) {
        filterDropdown.addEventListener('change', function() {
            console.log("选择了筛选选项: " + this.value);
            
            // 根据选项设置筛选参数
            switch(this.value) {
                case "距离排序":
                    currentFilter = 'distance';
                    break;
                case "薪资最高":
                    currentFilter = 'salary';
                    break;
                case "最新发布":
                    currentFilter = 'date';
                    break;
                default:
                    currentFilter = 'distance';
            }
            
            // 重置页码并重新加载
            currentPage = 1;
            hasMoreJobs = true;
            
            if (currentPosition) {
                loadNearbyJobs();
            } else {
                loadDefaultJobs();
            }
        });
    }
    
    // 搜索功能
    if (searchInput) {
        // 添加输入监听
        searchInput.addEventListener('input', function() {
            currentKeyword = this.value.trim();
        });
        
        // 添加搜索触发（按回车键）
        searchInput.addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
                if (currentKeyword) {
                    searchJobs();
                } else {
                    // 如果搜索框为空，恢复原始列表
                    currentPage = 1;
                    hasMoreJobs = true;
                    
                    if (currentPosition) {
                        loadNearbyJobs();
                    } else {
                        loadDefaultJobs();
                    }
                }
            }
        });
    }
    
    // 监听滚动加载更多
    window.addEventListener('scroll', () => {
        // 检查是否滚动到底部
        if (window.innerHeight + window.scrollY >= document.body.offsetHeight - 200) {
            // 如果有更多工作且不在加载中，加载下一页
            if (hasMoreJobs && !isLoading) {
                if (currentKeyword) {
                    searchJobs();
                } else if (currentPosition) {
                    loadNearbyJobs();
                } else {
                    loadDefaultJobs();
                }
            }
        }
    });
    
    // 初始化 - 获取位置并加载工作
    getLocation();
    
    // 添加CSS样式
    const style = document.createElement('style');
    style.textContent = `
        .loading-indicator {
            position: fixed;
            bottom: 20px;
            left: 50%;
            transform: translateX(-50%);
            background-color: rgba(0, 0, 0, 0.7);
            color: white;
            padding: 10px 20px;
            border-radius: 20px;
            display: flex;
            align-items: center;
            justify-content: center;
            z-index: 100;
        }
        
        .spinner {
            width: 20px;
            height: 20px;
            border: 2px solid rgba(255, 255, 255, 0.3);
            border-top: 2px solid white;
            border-radius: 50%;
            animation: spin 1s linear infinite;
            margin-right: 8px;
        }
        
        @keyframes spin {
            0% { transform: rotate(0deg); }
            100% { transform: rotate(360deg); }
        }
        
        .job-card {
            opacity: 0;
            transform: translateY(20px);
            transition: opacity 0.3s, transform 0.3s;
        }
        
        .job-card.show {
            opacity: 1;
            transform: translateY(0);
        }
        
        .empty-state {
            text-align: center;
            padding: 40px 0;
        }
        
        .empty-icon {
            width: 80px;
            height: 80px;
            margin-bottom: 16px;
            opacity: 0.5;
        }
        
        .empty-state p {
            color: #666;
            margin-bottom: 16px;
        }
        
        .retry-button {
            padding: 8px 16px;
            background-color: #1e88e5;
            color: white;
            border: none;
            border-radius: 4px;
            cursor: pointer;
        }
        
        .error-message {
            background-color: #ffebee;
            color: #d32f2f;
            padding: 10px 16px;
            border-radius: 4px;
            margin-bottom: 16px;
            transition: opacity 0.3s;
        }
        
        .error-message.fade-out {
            opacity: 0;
        }
    `;
    document.head.appendChild(style);
}); 